๋ฃจํ
์ ๋ ฅ ๊ฐ์ ํญ์ n ์ด๋ผ๊ณ ํ๊ธฐํ๋ค.
for(i=1;i<=n;i++){
m += 2;
}
์ฌ๊ธฐ์ m์ 2์ฉ ๋ํด์ฃผ๋ ๊ณ์ฐ์ c๋ผ๊ณ ํ๋ฉด
n๋ฒ ๋งํผ c๊ณ์ฐ์ด ์คํ๋๋๊ฒ์ด๋๊น c*n ์ ๋ณต์ก๋.
๊ทธ๋ฐ๋ฐ c์ ๊ฐ์ ์์๋ค์ ์ ์ธํ๊ณ ํ๊ธฐํ๋๊น O(n)์ ๋ณต์ก๋
์ค๋ณต ๋ฃจํ
for(i=1;i<=n;i++){
for(j=1;j<=n;j++){
k += 2;
}
}
์ฌ๊ธฐ์๋ n๋ฒ์ ๋ฐ๋ณตํ๋๋ฐ ๊ฐ ๋ฐ๋ณต๋ง๋ค n๋ฒ์ฉ ๋ฐ๋ณต๋ฌธ์ ์คํํ๋
(cโn)โn=n2 ๊ทธ๋์ O(n2)์ ๋ณต์ก๋๋ผ๊ณ ํ๊ธฐ
if-then-else
if(length()==0){
return false; // c0
}else{
... // c1
for(i=0;i<length();i++){
... // c2
if(){
... // c3
}
}
}
if๋ฅผ f(n), else๋ฅผ g(n)์ด๋ผ๊ณ ํ๊ณ
**max(f(n),g(n))**์ ๊ตฌํ๋ฉด ์ ์ผ ๋์ ๋ณต์ก๋๋ฅผ ๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๊ตฌํ ์ ์๋๋ฐ
์ด๊ฑธ f(n)+g(n) ์ด๋ผ๊ณ ํํํ๋ค๊ณ .
๋ง์ฝ f(n)์ด n4, g(n)์ด n3๋ผ๋ฉด n4+n3์ด ๋๊ณ
์์๊ฒ ์ฌ๋ผ์ง๋๊น O(n4)๋ง ๋จ๋๋ค.
์์ ์์๋ฅผ ๋ณด๋ฉด c0โ+c1โ+n(c2โ+c3โ) ๊ณ ์์๋ฅผ ์ ๊ฑฐํ๋ฉด O(n)์ ๋ณต์ก๋.
๋ก๊ทธํ ๋ณต์ก๋
์ด๋ค ์๊ณ ๋ฆฌ์ฆ์ ๋ฌธ์ ์ ํฌ๊ธฐ๋ฅผ ์ผ๋ถ ์ค์ด๋๋ฐ ์ผ์ ํ ์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค๋ฉด O(logn)
for(i=1;i<=n;){
i = i*2;
}
์์ ์ฝ๋๋ฅผ ๋ณด๋ฉด i++
์ด ์๋๋ผ 2์ฉ ๊ณฑํด์ฃผ๊ณ ์๋ค.
๋ง์ฝ n์ด 1000์ด๋ผ๋ฉด i๋ 1,2,4,8,16,32,64,128,256,512,1028, ... ๋ก ์งํ๋๋๋ฐ ๊ฑฐ๊ธฐ์ i<1000์ ๋ง์กฑํ๋ 512๊น์ง ๋ฐ๋ณต ํ์๋ 10์ด๋ค.
๊ณฑํ๊ธฐ 2์ฉ ํด์ฃผ๋๊น ๋ฐ๋ณตํ์๊ฐ k๋ผ๋ฉด i=2k์ธ๊ฒ.
๊ทธ๋์ log2โ๊ฐ ๋๊ณ n์ ์
๋ ฅ์ ์๋๊น log2โ1000
์์) ์ด์ง ๊ฒ์ - ์ฌ์ (nํ์ด์ง)์์ ๋จ์ด ์ฐพ๊ธฐ
n๊ฐ์ ์๋ฃ๊ฐ ์์๋ ํธ๋ฆฌ ์๋ฃํ์ ๊ด๋ฆฌ๋ฅผ ํด๋๋ค๋ฉด?
์๋ฅผ๋ค์ด 81๋ผ๋ ์ซ์๊ฐ ํธ๋ฆฌ์ ์๋์ง ํ์ธํ๋ ค๋ฉด, ๊ธฐ์กด ๋ฐฐ์ด์์๋ ์ต์
์ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ์ฒ์๋ถํฐ ๋๊น์ง ์ฆ n๋ฒ ์ฐ์ฐ์ ์คํํด์ผ ํ๋ค.
๊ทธ๋ฐ๋ฐ ํธ๋ฆฌํ์์๋ ํธ๋ฆฌ์ ๋์ด๋งํผ๋ง ํ์ธํด๋ณด๋ฉด 81์ด ์๋์ง ์๋์ง ์ ์ ์๋ค.
ํธ๋ฆฌ์ ๋์ด๋ n<2k ๋ก ๊ณ์ฐ๋๋ค. ์ฆ ๋ง์ฝ 14๊ฐ์ ์ซ์๊ฐ ์๋ค๊ณ ํ๋ฉด k๋ 4๊ณ ํธ๋ฆฌ์ ๋์ด๋ 4์ธต. ์ต๋ 4๋ฒ ํ์ธํด๋ณด๋ฉด ๋๋ค. (์ ์ ๋ ฌ๋์ด์๋ค๋ฉด)
๋ง์ฝ ์ฌ์ ์ ๋จ์ด๊ฐ 2๋ง๊ฐ๊ฐ ์๋ค๊ณ ๊ฐ์ ํ๋ฉด n=20000์ด๊ณ ์ด๊ฑธ log๋ฅผ ํ๋ฉด 14.3์ด ๋์ค๊ณ ํธ๋ฆฌ์ ๋์ด๋ 15์ธต.
์ฌ๊ทrecursion๋ ๋ฌด์์ธ๊ฐ?
์๊ธฐ ์์ ์ ํธ์ถํ๋ ํจ์.
์๊ธฐ ์์ ์ ๋ณต์ฌ๋ณธ์ ํธ์ถํ์ฌ ๋ ์์ ๋ฌธ์ ๋ฅผ ํ๊ฒ ํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค.
์์ ๋ฌธ์ ์ ์์ด์ ๊ฒฐ๊ตญ ๊ธฐ๋ณธ ๊ฒฝ์ฐ base case๋ก ์๋ ดํด์ผ ํ๋ค.
์ํ์ ๊ท๋ฉ๋ฒ์์
n=1์ ์ฆ๋ช
ํ๊ณ ,
n=i๋ฅผ ๊ฐ์ ํด์ n=i+1์ ์ฆ๋ช
ํ๋ฉด
์ฑ๊ณต์ ์ผ๋ก ์ฆ๋ช
์ ํ๋ค๊ณ ํ๋ค.
์ฌ๊ท๋ ์ด๊ฒ๊ณผ ๋น์ทํ๋ค.
์์) ํฉํ ๋ฆฌ์ผ
n!=1โ2โ3โ....โn
์ด๊ฑด ๋ค์ n!=nโ(nโ1)!๊ณผ ๊ฐ๋ค.
์ด๊ฑธ ์ฌ๊ทํจ์๋ก ๋ง๋ค๋ฉด
int Fact(int n){
if(n==1){ //base case
return 1;
}else if(n==0){ //base case
return 1;
}else{ //recursion step
return n*Fact(n-1); //๋ ์์์ง๋ค.
}
}
27์ด ์
๋ ฅ๋๋ค๋ฉด ๊ธฐ๋ณธ๊ฒฝ์ฐ์ ํด๋น๋์ง ์์ผ๋๊น 27*Fact(26)
์ ๋ฐํํ๋๋ฐ ์ด๊ฑด ๋ค์ 26*Fact(25)
๊ฐ ๋๊ณ ...... ๋ฐ๋ณต.
์ด ๊ฒฝ์ฐ์๋ for๋ฐ๋ณต๋ฌธ์ด ํจ์ฌ ์ง๊ด์ ์ด๊ณ ํธํ๊ธด ํ๋ค.
์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ์ ์์์์ฒ๋ผ ์ฌ๊ท์ ๊ฒฝ์ฐ recursion step๊ณผ ๊ธฐ๋ณธ ๊ฒฝ์ฐ base case ๋ ๊ฐ์ง๋ก ๋๋๊ณ . ๊ธฐ๋ณธ ๊ฒฝ์ฐ์ ์ข ๋ฃ๋๋ค.
์ฌ๊ท์ ๋ฉ๋ชจ๋ฆฌ
int Print(int n){
if(n==0){
return 0;
}else{
printf("%d",n);
return Print(n-1);
}
}
n=5๋ผ๋ฉด 5,4,3,2,1์ ์ถ๋ ฅํ๋ค.
๊ทธ๋ฐ๋ฐ ์ค์ ๋ก ๋ณด๋ฉด ๊ธฐ๋ณธ๊ฒฝ์ฐ์์ ๋ฐํํ๋ 0์ ์ญ์์ผ๋ก ์ญ ํ๊ณ ์ฌ๋ผ์จ๋ค.
์ถ๋ ฅ->(์ฌ๊ทํจ์)ํธ์ถ->์ถ๋ ฅ->ํธ์ถ->....-> 0 ๊ธฐ๋ณธ๊ฒฝ์ฐ์ ๋์ฐฉํ๋ฉด
๋ฐํ๋๋ 0์ Print(1)๋ก ์ฌ๋ผ๊ฐ๊ณ Print(1)์ Print(2)๋ก 0์ ๋ฐํํ๊ณ ์ด๋ ๊ฒ ์ฒ์ Print(5)๊น์ง ์ฌ๋ผ๊ฐ์ ๋ง์ง๋ง์ผ๋ก 0์ ๋ฐํํ๊ณ ์ข
๋ฃ.
๊ทธ๋ฌ๋๊น ์คํ์ Print(5)๊ฐ ์ฌ๋ผ๊ฐ๊ณ ๊ทธ ์์ Print(4)๊ฐ ์ฌ๋ผ๊ฐ๊ณ 3,2,1,0 ๊น์ง ์ฌ๋ผ๊ฐ๋ค๊ฐ 0,1,2 ์์๋๋ก ํ๋์ฉ ์ฌ๋ผ์ง๋ค(๊ฐ ํ์นธ์์ '์คํ ํ๋ ์'์ด๋ผ๊ณ ํ๋ค). ์ฆ ๋ฉ๋ชจ๋ฆฌ ์ถ๊ฐ ๊ณต๊ฐ์ด ํ์ํ๋ค๋ ๋ง.
๊ทธ๋์ ์ผ๋ฐ์ ์ผ๋ก for๋ฐ๋ณต๋ฌธ์ด ํจ์จ์ ์ด๋ค. ํ์ง๋ง ์ฌ๊ท๋ฅผ ์ฌ์ฉํด์ผ๋๋ ๋ง์ ๊ฒฝ์ฐ ๋์ ๋๋ ๋ฐ๋ณต์ ์๊ณ ๋ฆฌ์ฆ์ด ์์ ์ ์๊ณ ๊ทธ๋ ๋ค๋ฉด ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉ.